<?php
	/**
	  * @package	MyDebuger
	  * @name		MyTools
	  * @brief		Clase con funciones estaticas de herramientas
	  * @author		Hermann D. Schimpf <hschimpf@gschimpf.com>
	  * @license	http://opensource.org/licenses/gpl-2.0.php
	  * @date		2009-12-21
	  * @version	0.2.8
  	**/

	final class MyTools extends MyDebuger implements MyVersions {
		/* version de la clase */
		private static $version			= 0;
		/* subversion de la clase */
		private static $subversion		= 2;
		/* numero de revision de la clase */
		private static $revision		= 8;

		public final function __construct($debug = False, $name = __CLASS__) {
			/* creamos el padre */
			parent::__construct($debug, $name, 086);
			/* habilitamos el registro en un fichero */
			$this->enableLog($name . '.log');
		}

		public function __destruct() {
			/* matamos el padre */
			parent::__destruct();
		}

		public static final function getVersion() {
			/* retornamos la version actual de la clase */
			return 'v' . self::$version . '.' . self::$subversion . '.' . self::$revision;
		}

		public static function showDefinitionOf($classOrInterface = Null, $showPrivates = False) {
			try {
				try {
					/* creamos la instancia */
					$showDefinitionOf = new MyTools;
					/* mostramos un mensaje */
					$showDefinitionOf->show('Verificando existencia de la clase ' . $showDefinitionOf->italic('ClassDefinitor') . '..', False);
					/* verificamos si existe la clase */
					if (!class_exists('ClassDefinitor'))
						/* salimos con una excepcion */
						$showDefinitionOf->newException('La clase' . $showDefinitionOf->italic('ClassDefinitor') . ' no existe');
					/* mostramos ok al mensaje */
					$showDefinitionOf->showOK();
					/* retornamos el resultado del metodo */
					return ClassDefinitor::showDefinitionOf($classOrInterface, $showPrivates);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$showDefinitionOf->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$showDefinitionOf->show($e->getMensaje());
			}
		}

		public static function validateUrl($url = Null) {
			try {
				try {
					/* creamos la instancia */
					$validateUrl = new MyTools;
					/* mostramos un mensaje */
					$validateUrl->show('Verificando existencia de la clase ' . $validateUrl->italic('UrlValidator') . '..', False);
					/* verificamos si existe la clase */
					if (!class_exists('UrlValidator'))
						/* salimos con una excepcion */
						$validateUrl->newException('La clase' . $validateUrl->italic('UrlValidator') . ' no existe');
					/* mostramos ok al mensaje */
					$validateUrl->showOK();
					/* retornamos el resultado del metodo */
					return UrlValidator::validateUrl($url);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$validateUrl->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$validateUrl->show($e->getMensaje());
			}
		}

		public static function validateEmail($email = Null) {
			try {
				try {
					/* creamos la instancia */
					$validateEmail = new MyTools;
					/* mostramos un mensaje */
					$validateEmail->show('Verificando existencia de la clase ' . $validateEmail->italic('EmailValidator') . '..', False);
					/* verificamos si existe la clase */
					if (!class_exists('EmailValidator'))
						/* salimos con una excepcion */
						$validateEmail->newException('La clase' . $validateEmail->italic('EmailValidator') . ' no existe');
					/* mostramos ok al mensaje */
					$validateEmail->showOK();
					/* retornamos el resultado del metodo */
					return EmailValidator::validateEmail($email);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$validateEmail->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$validateEmail->show($e->getMensaje());
			}
		}

		public static function convertToWords($number = Null) {
			try {
				try {
					/* creamos la instancia */
					$convertToWrods = new MyTools;
					/* mostramos un mensaje */
					$convertToWrods->show('Verificando existencia de la clase ' . $convertToWrods->italic('NumberConverter') . '..', False);
					/* verificamos si existe la clase */
					if (!class_exists('NumberConverter'))
						/* salimos con una excepcion */
						$convertToWrods->newException('La clase' . $convertToWrods->italic('NumberConverter') . ' no existe');
					/* mostramos ok al mensaje */
					$convertToWrods->showOK();
					/* retornamos el resultado del metodo */
					return NumberConverter::convertToWords($number);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$convertToWrods->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$convertToWrods->show($e->getMensaje());
			}
		}

		public static function validateUserName($userName = Null) {
			try {
				try {
					/* creamos la instancia */
					$validateUserName = new MyTools;
					/* mostramos un mensaje */
					$validateUserName->show('Verificando existencia de la clase ' . $validateUserName->italic('UserNameValidator') . '..', False);
					/* verificamos si existe la clase */
					if (!class_exists('UserNameValidator'))
						/* salimos con una excepcion */
						$validateUserName->newException('La clase' . $validateUserName->italic('UserNameValidator') . ' no existe');
					/* mostramos ok al mensaje */
					$validateUserName->showOK();
					/* retornamos el resultado del metodo */
					return UserNameValidator::validateUserName($userName);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$validateUserName->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$validateUserName->show($e->getMensaje());
			}
		}

		public static function validateIp($ipDir = Null) {
			try {
				try {
					/* creamos la instancia */
					$validateIp = new MyTools;
					/* mostramos un mensaje */
					$validateIp->show('Verificando existencia de la clase ' . $validateIp->italic('IpValidator') . '..', False);
					/* verificamos si existe la clase */
					if (!class_exists('IpValidator'))
						/* salimos con una excepcion */
						$validateIp->newException('La clase' . $validateIp->italic('IpValidator') . ' no existe');
					/* mostramos ok al mensaje */
					$validateIp->showOK();
					/* retornamos el resultado del metodo */
					return IpValidator::validateIp($ipDir);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$validateIp->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$validateIp->show($e->getMensaje());
			}
		}

		public static function replaceBBCode($string = Null) {
			try {
				try {
					/* creamos la instancia */
					$replaceBBCode = new MyTools;
					/* mostramos un mensaje */
					$replaceBBCode->show('Verificando existencia de la clase ' . $replaceBBCode->italic('BBCodeGenerator') . '..', False);
					/* verificamos si existe la clase */
					if (!class_exists('BBCodeGenerator'))
						/* salimos con una excepcion */
						$replaceBBCode->newException('La clase' . $replaceBBCode->italic('BBCodeGenerator') . ' no existe');
					/* mostramos ok al mensaje */
					$replaceBBCode->showOK();
					/* retornamos el resultado del metodo */
					return BBCodeGenerator::replaceBBCode($string);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$replaceBBCode->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$replaceBBCode->show($e->getMensaje());
			}
		}

		public static function ObjectToArray($object = Null) {
			try {
				try {
					/* creamos la instancia */
					$ObjectToArray = new MyTools;
					/* mostramos un mensaje */
					$ObjectToArray->show('Verificando existencia de la clase ' . $ObjectToArray->italic('ObjectToArray') . '..', False);
					/* verificamos si existe la clase */
					if (!class_exists('ObjectToArray'))
						/* salimos con una excepcion */
						$ObjectToArray->newException('La clase' . $ObjectToArray->italic('ObjectToArray') . ' no existe');
					/* mostramos ok al mensaje */
					$ObjectToArray->showOK();
					/* retornamos el resultado del metodo */
					return ObjectToArray::toArray($object);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$ObjectToArray->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$ObjectToArray->show($e->getMensaje());
			}
		}

		public static function ArrayToObject($array = Null) {
			try {
				try {
					/* creamos la instancia */
					$ArrayToObject = new MyTools;
					/* mostramos un mensaje */
					$ArrayToObject->show('Verificando existencia de la clase ' . $ArrayToObject->italic('ObjectToArray') . '..', False);
					/* verificamos si existe la clase */
					if (!class_exists('ObjectToArray'))
						/* salimos con una excepcion */
						$ArrayToObject->newException('La clase' . $ArrayToObject->italic('ObjectToArray') . ' no existe');
					/* mostramos ok al mensaje */
					$ArrayToObject->showOK();
					/* retornamos el resultado del metodo */
					return ObjectToArray::toObject($array);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$ArrayToObject->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$ArrayToObject->show($e->getMensaje());
			}
		}

		public static function getCombinations($elements = Null) {
			try {
				try {
					/* creamos la instancia */
					$getCombinations = new MyTools;
					/* mostramos un mensaje */
					$getCombinations->show('Verificando existencia de la clase ' . $getCombinations->italic('CombinationsBuilder') . '..', False);
					/* verificamos si existe la clase */
					if (!class_exists('CombinationsBuilder'))
						/* salimos con una excepcion */
						$getCombinations->newException('La clase' . $getCombinations->italic('CombinationsBuilder') . ' no existe');
					/* mostramos ok al mensaje */
					$getCombinations->showOK();
					/* retornamos el resultado del metodo */
					return CombinationsBuilder::getCombinations($elements);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$getCombinations->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$getCombinations->show($e->getMensaje());
			}
		}

		public static function encrypt($value = Null, $key = Null) {
			try {
				try {
					/* creamos la instancia */
					$encrypt = new MyTools;
					/* mostramos un mensaje */
					$encrypt->show('Verificando existencia de la clase ' . $encrypt->italic('Crypter') . '..', False);
					/* verificamos si existe la clase */
					if (!class_exists('Crypter'))
						/* salimos con una excepcion */
						$encrypt->newException('La clase' . $encrypt->italic('Crypter') . ' no existe');
					/* mostramos ok al mensaje */
					$encrypt->showOK();
					/* retornamos el resultado del metodo */
					return Crypter::encrypt($value, $key);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$encrypt->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$encrypt->show($e->getMensaje());
			}
		}

		public static function decrypt($value = Null, $key = Null) {
			try {
				try {
					/* creamos la instancia */
					$decrypt = new MyTools;
					/* mostramos un mensaje */
					$decrypt->show('Verificando existencia de la clase ' . $decrypt->italic('Crypter') . '..', False);
					/* verificamos si existe la clase */
					if (!class_exists('Crypter'))
						/* salimos con una excepcion */
						$decrypt->newException('La clase' . $decrypt->italic('Crypter') . ' no existe');
					/* mostramos ok al mensaje */
					$decrypt->showOK();
					/* retornamos el resultado del metodo */
					return Crypter::decrypt($value, $key);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$decrypt->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$decrypt->show($e->getMensaje());
			}
		}
	}
?>